//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Braket service.
///
/// The Amazon Braket API Reference provides information about the operations and structures supported in Amazon Braket. Additional Resources:    Amazon Braket Developer Guide
public struct Braket: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Braket client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Braket",
            serviceIdentifier: "braket",
            serviceProtocol: .restjson,
            apiVersion: "2019-09-01",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: BraketErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "eu-north-1": "braket.eu-north-1.api.aws",
            "eu-west-2": "braket.eu-west-2.api.aws",
            "us-east-1": "braket.us-east-1.api.aws",
            "us-west-1": "braket.us-west-1.api.aws",
            "us-west-2": "braket.us-west-2.api.aws"
        ])
    ]}

    // MARK: API Calls

    /// Cancels an Amazon Braket job.
    @Sendable
    @inlinable
    public func cancelJob(_ input: CancelJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelJobResponse {
        try await self.client.execute(
            operation: "CancelJob", 
            path: "/job/{jobArn}/cancel", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels an Amazon Braket job.
    ///
    /// Parameters:
    ///   - jobArn: The ARN of the Amazon Braket job to cancel.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelJob(
        jobArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelJobResponse {
        let input = CancelJobRequest(
            jobArn: jobArn
        )
        return try await self.cancelJob(input, logger: logger)
    }

    /// Cancels the specified task.
    @Sendable
    @inlinable
    public func cancelQuantumTask(_ input: CancelQuantumTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelQuantumTaskResponse {
        try await self.client.execute(
            operation: "CancelQuantumTask", 
            path: "/quantum-task/{quantumTaskArn}/cancel", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels the specified task.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the request.
    ///   - quantumTaskArn: The ARN of the task to cancel.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelQuantumTask(
        clientToken: String = CancelQuantumTaskRequest.idempotencyToken(),
        quantumTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelQuantumTaskResponse {
        let input = CancelQuantumTaskRequest(
            clientToken: clientToken, 
            quantumTaskArn: quantumTaskArn
        )
        return try await self.cancelQuantumTask(input, logger: logger)
    }

    /// Creates an Amazon Braket job.
    @Sendable
    @inlinable
    public func createJob(_ input: CreateJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateJobResponse {
        try await self.client.execute(
            operation: "CreateJob", 
            path: "/job", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Braket job.
    ///
    /// Parameters:
    ///   - algorithmSpecification: Definition of the Amazon Braket job to be created. Specifies the container image the job uses and information about the Python scripts used for entry and training.
    ///   - associations: The list of Amazon Braket resources associated with the hybrid job.
    ///   - checkpointConfig: Information about the output locations for job checkpoint data.
    ///   - clientToken: A unique token that guarantees that the call to this API is idempotent.
    ///   - deviceConfig: The quantum processing unit (QPU) or simulator used to create an Amazon Braket job.
    ///   - hyperParameters: Algorithm-specific parameters used by an Amazon Braket job that influence the quality of the training job. The values are set with a string of JSON key:value pairs, where the key is the name of the hyperparameter and the value is the value of th hyperparameter.
    ///   - inputDataConfig: A list of parameters that specify the name and type of input data and where it is located.
    ///   - instanceConfig: Configuration of the resource instances to use while running the hybrid job on Amazon Braket.
    ///   - jobName: The name of the Amazon Braket job.
    ///   - outputDataConfig: The path to the S3 location where you want to store job artifacts and the encryption key used to store them.
    ///   - roleArn: The Amazon Resource Name (ARN) of an IAM role that Amazon Braket can assume to perform tasks on behalf of a user. It can access user resources, run an Amazon Braket job container on behalf of user, and output resources to the users' s3 buckets.
    ///   - stoppingCondition:  The user-defined criteria that specifies when a job stops running.
    ///   - tags: A tag object that consists of a key and an optional value, used to manage metadata for Amazon Braket resources.
    ///   - logger: Logger use during operation
    @inlinable
    public func createJob(
        algorithmSpecification: AlgorithmSpecification,
        associations: [Association]? = nil,
        checkpointConfig: JobCheckpointConfig? = nil,
        clientToken: String = CreateJobRequest.idempotencyToken(),
        deviceConfig: DeviceConfig,
        hyperParameters: [String: String]? = nil,
        inputDataConfig: [InputFileConfig]? = nil,
        instanceConfig: InstanceConfig,
        jobName: String,
        outputDataConfig: JobOutputDataConfig,
        roleArn: String,
        stoppingCondition: JobStoppingCondition? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateJobResponse {
        let input = CreateJobRequest(
            algorithmSpecification: algorithmSpecification, 
            associations: associations, 
            checkpointConfig: checkpointConfig, 
            clientToken: clientToken, 
            deviceConfig: deviceConfig, 
            hyperParameters: hyperParameters, 
            inputDataConfig: inputDataConfig, 
            instanceConfig: instanceConfig, 
            jobName: jobName, 
            outputDataConfig: outputDataConfig, 
            roleArn: roleArn, 
            stoppingCondition: stoppingCondition, 
            tags: tags
        )
        return try await self.createJob(input, logger: logger)
    }

    /// Creates a quantum task.
    @Sendable
    @inlinable
    public func createQuantumTask(_ input: CreateQuantumTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateQuantumTaskResponse {
        try await self.client.execute(
            operation: "CreateQuantumTask", 
            path: "/quantum-task", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a quantum task.
    ///
    /// Parameters:
    ///   - action: The action associated with the task.
    ///   - associations: The list of Amazon Braket resources associated with the quantum task.
    ///   - clientToken: The client token associated with the request.
    ///   - deviceArn: The ARN of the device to run the task on.
    ///   - deviceParameters: The parameters for the device to run the task on.
    ///   - jobToken: The token for an Amazon Braket job that associates it with the quantum task.
    ///   - outputS3Bucket: The S3 bucket to store task result files in.
    ///   - outputS3KeyPrefix: The key prefix for the location in the S3 bucket to store task results in.
    ///   - shots: The number of shots to use for the task.
    ///   - tags: Tags to be added to the quantum task you're creating.
    ///   - logger: Logger use during operation
    @inlinable
    public func createQuantumTask(
        action: String,
        associations: [Association]? = nil,
        clientToken: String = CreateQuantumTaskRequest.idempotencyToken(),
        deviceArn: String,
        deviceParameters: String? = nil,
        jobToken: String? = nil,
        outputS3Bucket: String,
        outputS3KeyPrefix: String,
        shots: Int64,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateQuantumTaskResponse {
        let input = CreateQuantumTaskRequest(
            action: action, 
            associations: associations, 
            clientToken: clientToken, 
            deviceArn: deviceArn, 
            deviceParameters: deviceParameters, 
            jobToken: jobToken, 
            outputS3Bucket: outputS3Bucket, 
            outputS3KeyPrefix: outputS3KeyPrefix, 
            shots: shots, 
            tags: tags
        )
        return try await self.createQuantumTask(input, logger: logger)
    }

    /// Retrieves the devices available in Amazon Braket.  For backwards compatibility with older versions of BraketSchemas, OpenQASM information is omitted from GetDevice API calls. To get this information the user-agent needs to present a recent version of the BraketSchemas (1.8.0 or later). The Braket SDK automatically reports this for you. If you do not see OpenQASM results in the GetDevice response when using a Braket SDK, you may need to set AWS_EXECUTION_ENV environment variable to configure user-agent. See the code examples provided below for how to do this for the AWS CLI, Boto3, and the Go, Java, and JavaScript/TypeScript SDKs.
    @Sendable
    @inlinable
    public func getDevice(_ input: GetDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDeviceResponse {
        try await self.client.execute(
            operation: "GetDevice", 
            path: "/device/{deviceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the devices available in Amazon Braket.  For backwards compatibility with older versions of BraketSchemas, OpenQASM information is omitted from GetDevice API calls. To get this information the user-agent needs to present a recent version of the BraketSchemas (1.8.0 or later). The Braket SDK automatically reports this for you. If you do not see OpenQASM results in the GetDevice response when using a Braket SDK, you may need to set AWS_EXECUTION_ENV environment variable to configure user-agent. See the code examples provided below for how to do this for the AWS CLI, Boto3, and the Go, Java, and JavaScript/TypeScript SDKs.
    ///
    /// Parameters:
    ///   - deviceArn: The ARN of the device to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDevice(
        deviceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceResponse {
        let input = GetDeviceRequest(
            deviceArn: deviceArn
        )
        return try await self.getDevice(input, logger: logger)
    }

    /// Retrieves the specified Amazon Braket job.
    @Sendable
    @inlinable
    public func getJob(_ input: GetJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJobResponse {
        try await self.client.execute(
            operation: "GetJob", 
            path: "/job/{jobArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the specified Amazon Braket job.
    ///
    /// Parameters:
    ///   - additionalAttributeNames: A list of attributes to return information for.
    ///   - jobArn: The ARN of the job to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJob(
        additionalAttributeNames: [HybridJobAdditionalAttributeName]? = nil,
        jobArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJobResponse {
        let input = GetJobRequest(
            additionalAttributeNames: additionalAttributeNames, 
            jobArn: jobArn
        )
        return try await self.getJob(input, logger: logger)
    }

    /// Retrieves the specified quantum task.
    @Sendable
    @inlinable
    public func getQuantumTask(_ input: GetQuantumTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetQuantumTaskResponse {
        try await self.client.execute(
            operation: "GetQuantumTask", 
            path: "/quantum-task/{quantumTaskArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the specified quantum task.
    ///
    /// Parameters:
    ///   - additionalAttributeNames: A list of attributes to return information for.
    ///   - quantumTaskArn: The ARN of the task to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getQuantumTask(
        additionalAttributeNames: [QuantumTaskAdditionalAttributeName]? = nil,
        quantumTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetQuantumTaskResponse {
        let input = GetQuantumTaskRequest(
            additionalAttributeNames: additionalAttributeNames, 
            quantumTaskArn: quantumTaskArn
        )
        return try await self.getQuantumTask(input, logger: logger)
    }

    /// Shows the tags associated with this resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Shows the tags associated with this resource.
    ///
    /// Parameters:
    ///   - resourceArn: Specify the resourceArn for the resource whose tags to display.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Searches for devices using the specified filters.
    @Sendable
    @inlinable
    public func searchDevices(_ input: SearchDevicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchDevicesResponse {
        try await self.client.execute(
            operation: "SearchDevices", 
            path: "/devices", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for devices using the specified filters.
    ///
    /// Parameters:
    ///   - filters: The filter values to use to search for a device.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token used for pagination of results returned in the response. Use the token returned from the previous request continue results where the previous request ended.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchDevices(
        filters: [SearchDevicesFilter],
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchDevicesResponse {
        let input = SearchDevicesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchDevices(input, logger: logger)
    }

    /// Searches for Amazon Braket jobs that match the specified filter values.
    @Sendable
    @inlinable
    public func searchJobs(_ input: SearchJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchJobsResponse {
        try await self.client.execute(
            operation: "SearchJobs", 
            path: "/jobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for Amazon Braket jobs that match the specified filter values.
    ///
    /// Parameters:
    ///   - filters: The filter values to use when searching for a job.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token used for pagination of results returned in the response. Use the token returned from the previous request to continue results where the previous request ended.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchJobs(
        filters: [SearchJobsFilter],
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchJobsResponse {
        let input = SearchJobsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchJobs(input, logger: logger)
    }

    /// Searches for tasks that match the specified filter values.
    @Sendable
    @inlinable
    public func searchQuantumTasks(_ input: SearchQuantumTasksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchQuantumTasksResponse {
        try await self.client.execute(
            operation: "SearchQuantumTasks", 
            path: "/quantum-tasks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for tasks that match the specified filter values.
    ///
    /// Parameters:
    ///   - filters: Array of SearchQuantumTasksFilter objects.
    ///   - maxResults: Maximum number of results to return in the response.
    ///   - nextToken: A token used for pagination of results returned in the response. Use the token returned from the previous request continue results where the previous request ended.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchQuantumTasks(
        filters: [SearchQuantumTasksFilter],
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchQuantumTasksResponse {
        let input = SearchQuantumTasksRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchQuantumTasks(input, logger: logger)
    }

    /// Add a tag to the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Add a tag to the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: Specify the resourceArn of the resource to which a tag will be added.
    ///   - tags: Specify the tags to add to the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Remove tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Remove tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: Specify the resourceArn for the resource from which to remove the tags.
    ///   - tagKeys: Specify the keys for the tags to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }
}

extension Braket {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Braket, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Braket {
    /// Return PaginatorSequence for operation ``searchDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchDevicesPaginator(
        _ input: SearchDevicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchDevicesRequest, SearchDevicesResponse> {
        return .init(
            input: input,
            command: self.searchDevices,
            inputKey: \SearchDevicesRequest.nextToken,
            outputKey: \SearchDevicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filter values to use to search for a device.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchDevicesPaginator(
        filters: [SearchDevicesFilter],
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchDevicesRequest, SearchDevicesResponse> {
        let input = SearchDevicesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchDevicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchJobsPaginator(
        _ input: SearchJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchJobsRequest, SearchJobsResponse> {
        return .init(
            input: input,
            command: self.searchJobs,
            inputKey: \SearchJobsRequest.nextToken,
            outputKey: \SearchJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filter values to use when searching for a job.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchJobsPaginator(
        filters: [SearchJobsFilter],
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchJobsRequest, SearchJobsResponse> {
        let input = SearchJobsRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchQuantumTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuantumTasksPaginator(
        _ input: SearchQuantumTasksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchQuantumTasksRequest, SearchQuantumTasksResponse> {
        return .init(
            input: input,
            command: self.searchQuantumTasks,
            inputKey: \SearchQuantumTasksRequest.nextToken,
            outputKey: \SearchQuantumTasksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchQuantumTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Array of SearchQuantumTasksFilter objects.
    ///   - maxResults: Maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuantumTasksPaginator(
        filters: [SearchQuantumTasksFilter],
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchQuantumTasksRequest, SearchQuantumTasksResponse> {
        let input = SearchQuantumTasksRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchQuantumTasksPaginator(input, logger: logger)
    }
}

extension Braket.SearchDevicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Braket.SearchDevicesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Braket.SearchJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Braket.SearchJobsRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Braket.SearchQuantumTasksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Braket.SearchQuantumTasksRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
